import scala.collection.{SortedSet, mutable}
import scala.collection.immutable._;
/**
  * @Author Mr.An
  * @Date 18/5/16 下午2:12
  *      1. 编写一个函数，给定字符串，产出一个包含所有字符的下标的映射。举例来说：indexes(“Mississippi”)应返回一个映射，让’M’对应集{0}，’i’对应集{1,4,7,10}，依此类推。使用字符到可变集的映射。另外，你如何保证集是经过排序的？
  *2. 重复前一个练习，这次用字符到列表的不可变映射。
  * 
  */
object ScalaCollectionTest {
  val str="Mississippi"
  def fun(c:Char,n:Int,set:Set[Int]): Set[Int] ={
    set+n

  }

  def main(args: Array[String]): Unit = {
    val rst=str.zipWithIndex.groupBy(_._1)
    println(rst)
    val rst2=rst.map(x=>{
      x._1->x._2.map(y=>{
        y._2
      })
    })
    println(rst2)
    val rst3=rst2.map(x=>{
      x._1->x._2.toSet
    })
    println("___"*20+"zipwithindex groupby map map")
    println(rst3)
    println("___"*20)
    var m=new scala.collection.mutable.HashMap[Char,collection.mutable.SortedSet[Int]]()
    var i=0;
    for(c <- str){
      m.get(c) match {
        case Some(set)=>m(c)=set+i
        case None=>m(c)=collection.mutable.SortedSet[Int](i)
      }
      i+=1
    }
    println("___"*20+"mutable hashmap")
    println(m)
    println("___"*20)

    val m2=charSort(str,Map())
    println("___"*20+"imutable list")
    println(m2)
    println("___"*20)
    var l=List[Int]()
    l=l.+:(1)
    l=l:+2
    println(l)

    println("___"*40)

    var mm=Map[String,Int]()
    mm=mm+("ss"->11)
    mm=mm+("ss"->21)
    println(mm.get("ss"))

    (0 to 4).foreach(x=>{
      println(x+"___"*40)
    })
    for(i <-(0 to 4)){
      println(i+"___"*40)
    }

    var mu=mutable.Map[String,Int]()
    //不管是不是可变集合只要＋elem 就会新建一个集合，所以原变量要重新赋值！！
    mu=mu+("22"->22)
    mu=mu+("23"->23)

    println(mu)



  }
//用集合执行修改。  Map ＋ elem（不管这个元素在不在之前的集合中,不管是不是可变集合）肯定会新生成一个新集合，所以别忘了赋值
  def charSort(str:String,m:Map[Char,List[Int]]) ={
    var index=0;
    var ml=m
    str.foreach(c=>{
      ml.get(c) match {
        case Some(result)=>ml=ml+(c->(result:+index))
        case None=> ml=ml+(c->List(index))
      }
      index+=1
    }

    )
    ml
  }



}
